const WXAPI = require('apifm-wxapi')

/**
 * 检查当前会话是否有效。
 * 该函数没有参数。
 * @returns {Promise<boolean>} 返回一个Promise对象，如果会话有效，则resolve为true，否则resolve为false。
 */
async function checkSession(){
  return new Promise((resolve, reject) => {
    // 使用微信小程序的checkSession接口检查会话状态
    wx.checkSession({
      success() {
        // 会话有效时的处理逻辑
        return resolve(true)
      },
      fail() {
        // 会话无效时的处理逻辑
        return resolve(false)
      }
    })
  })
}


/**
 * 异步绑定卖家函数
 * 该函数用于将用户与卖家进行绑定操作，需要用户token和引荐人信息。
 * 注意：该函数不接受任何参数，也不直接返回任何结果。
 */
async function bindSeller() {
  // 从存储中获取用户token
  const token = wx.getStorageSync('token')
  // 从存储中获取引荐人信息
  const referrer = wx.getStorageSync('referrer')

  // 检查token是否存在
  if (!token) {
    return
  }

  // 检查引荐人信息是否存在
  if (!referrer) {
    return
  }

  // 调用API进行卖家绑定操作
  const res = await WXAPI.bindSeller({
    token,
    uid: referrer
  })
}


/**
 * 检查用户是否已登录
 * 该函数没有参数
 * @returns {Boolean} 返回一个布尔值，如果用户已登录则返回true，否则返回false
 */
async function checkHasLogined() {
  // 从存储中获取用户token
  const token = wx.getStorageSync('token')
  // 如果没有token，表示用户未登录
  if (!token) {
    return false
  }
  // 检查会话是否有效
  const loggined = await checkSession()
  // 如果会话无效，清除token并返回未登录状态
  if (!loggined) {
    wx.removeStorageSync('token')
    return false
  }
  // 校验token的有效性
  const checkTokenRes = await WXAPI.checkToken(token)
  // 如果token校验失败，清除token并返回未登录状态
  if (checkTokenRes.code !== 0) {
    wx.removeStorageSync('token')
    return false
  }
  // 以上条件都通过，表示用户已登录
  return true
}


/**
 * 异步函数，用于获取微信小程序的登录code。
 * 无参数。
 * @returns {Promise<string>} 返回一个Promise对象，成功时resolve一个字符串类型的code，失败时resolve一个字符串'获取code失败'。
 */
async function wxaCode(){
  return new Promise((resolve, reject) => {
    // 微信登录接口调用
    wx.login({
      success(res) {
        // 登录成功，返回微信提供的code
        return resolve(res.code)
      },
      fail() {
        // 登录失败，显示提示信息，并返回失败标识
        wx.showToast({
          title: '获取code失败',
          icon: 'none'
        })
        return resolve('获取code失败')
      }
    })
  })
}


/**
 * 异步登录函数
 * @param {Object} page - 页面对象，用于在登录成功后回调页面的onShow方法
 * 该函数无返回值
 */
async function login(page){
  const _this = this
  wx.login({
    success: function (res) {
      const componentAppid = wx.getStorageSync('componentAppid')
      // 判断是否已存在componentAppid，进行不同的登录处理
      if (componentAppid) {
        // 使用componentAppid进行服务号登录处理
        WXAPI.wxappServiceLogin({
          componentAppid,
          appid: wx.getStorageSync('appid'),
          code: res.code
        }).then(function (res) {
          // 登录失败，跳转注册
          if (res.code == 10000) {
            return;
          }
          // 登录错误，显示错误信息
          if (res.code != 0) {
            wx.showModal({
              title: '无法登录',
              content: res.msg,
              showCancel: false
            })
            return;
          }
          // 登录成功，存储token和uid
          wx.setStorageSync('token', res.data.token)
          wx.setStorageSync('uid', res.data.uid)
          // 绑定卖家信息
          _this.bindSeller()
          // 如果存在page参数，则回调页面的onShow方法
          if ( page ) {
            page.onShow()
          }
        })
      } else {
        // 未存在componentAppid，进行普通小程序登录处理
        WXAPI.login_wx(res.code).then(function (res) {
          // 登录失败，跳转注册
          if (res.code == 10000) {
            return;
          }
          // 登录错误，显示错误信息
          if (res.code != 0) {
            wx.showModal({
              title: '无法登录',
              content: res.msg,
              showCancel: false
            })
            return;
          }
          // 登录成功，存储token和uid
          wx.setStorageSync('token', res.data.token)
          wx.setStorageSync('uid', res.data.uid)
          // 绑定卖家信息
          _this.bindSeller()
          // 如果存在page参数，则回调页面的onShow方法
          if ( page ) {
            page.onShow()
          }
        })
      }
    }
  })
}


/**
 * 授权函数，用于获取用户的授权信息。
 * 该函数不接受任何参数。
 *
 * @returns {Promise} 返回一个Promise对象，成功时resolve携带授权信息，失败时reject携带错误信息。
 */
async function authorize() {
  return new Promise((resolve, reject) => {
    // 微信登录接口调用
    wx.login({
      success: function (res) {
        const code = res.code // 获取登录凭证
        let referrer = '' // 初始化推荐人字段
        // 尝试从存储中获取推荐人信息
        let referrer_storge = wx.getStorageSync('referrer');
        if (referrer_storge) {
          referrer = referrer_storge;
        }
        // 根据组件应用ID调用不同的授权接口
        const componentAppid = wx.getStorageSync('componentAppid')
        if (componentAppid) {
          // 调用组件应用授权接口
          WXAPI.wxappServiceAuthorize({
            code: code,
            referrer: referrer
          }).then(function (res) {
            if (res.code == 0) {
              // 授权成功，存储token和uid
              wx.setStorageSync('token', res.data.token)
              wx.setStorageSync('uid', res.data.uid)
              resolve(res)
            } else {
              // 授权失败，显示提示信息
              wx.showToast({
                title: res.msg,
                icon: 'none'
              })
              reject(res.msg)
            }
          })
        } else {
          // 调用普通授权接口
          WXAPI.authorize({
            code: code,
            referrer: referrer
          }).then(function (res) {
            if (res.code == 0) {
              // 授权成功，存储token和uid
              wx.setStorageSync('token', res.data.token)
              wx.setStorageSync('uid', res.data.uid)
              resolve(res)
            } else {
              // 授权失败，显示提示信息
              wx.showToast({
                title: res.msg,
                icon: 'none'
              })
              reject(res.msg)
            }
          })
        }
      },
      fail: err => {
        // 登录失败，拒绝Promise
        reject(err)
      }
    })
  })
}


/**
 * 登出功能实现
 * 该函数没有参数。
 * 该函数没有返回值。
 */
function loginOut(){
  // 移除用户令牌(token)和用户ID(uid)的本地存储
  wx.removeStorageSync('token')
  wx.removeStorageSync('uid')
}


/**
 * 检查并授权
 * @param {string} scope 需要授权的权限范围
 * @returns {Promise} Promise对象，成功时无返回参数，失败时返回错误信息
 */
async function checkAndAuthorize (scope) {
  return new Promise((resolve, reject) => {
    wx.getSetting({ // 获取当前用户授权设置
      success(res) {
        if (!res.authSetting[scope]) { // 如果未授权
          wx.authorize({ // 请求授权
            scope: scope,
            success() {
              resolve() // 授权成功，解决Promise
            },
            fail(e){
              console.error(e)
              // 显示授权被拒绝的提示
              wx.showModal({
                title: '无权操作',
                content: '需要获得您的授权',
                showCancel: false,
                confirmText: '立即授权',
                confirmColor: '#e64340',
                success(res) {
                  wx.openSetting(); // 打开设置页面，以便用户授权
                },
                fail(e){
                  console.error(e)
                  reject(e) // 弹窗操作失败，拒绝Promise
                },
              })
            }
          })
        } else {
          resolve() // 已授权，解决Promise
        }
      },
      fail(e){
        console.error(e)
        reject(e) // 获取设置失败，拒绝Promise
      }
    })
  })
}


module.exports = {
  checkHasLogined: checkHasLogined,
  wxaCode: wxaCode,
  login: login,
  loginOut: loginOut,
  checkAndAuthorize: checkAndAuthorize,
  authorize: authorize,
  bindSeller: bindSeller
}
